import { ElMessage } from 'element-plus';

// 错误类型枚举
export enum ErrorType {
  NETWORK = 'network',
  VALIDATION = 'validation',
  AUTH = 'auth',
  SERVER = 'server',
  UNKNOWN = 'unknown'
}

// 错误信息接口
export interface ErrorInfo {
  type: ErrorType;
  message: string;
  details?: any;
  status?: number;
}

// 全局错误处理类
export class ErrorHandler {
  /**
   * 处理API错误
   * @param error 错误对象
   * @param customMessage 自定义错误消息
   */
  static handleApiError(error: any, customMessage?: string): ErrorInfo {
    console.error('API Error:', error);
    
    let errorInfo: ErrorInfo = {
      type: ErrorType.UNKNOWN,
      message: customMessage || '操作失败，请稍后重试'
    };

    // 处理网络错误
    if (!error.response) {
      errorInfo.type = ErrorType.NETWORK;
      errorInfo.message = '网络连接失败，请检查网络设置';
      ElMessage.error(errorInfo.message);
      return errorInfo;
    }

    const { status, data } = error.response;
    errorInfo.status = status;

    // 处理不同类型的HTTP状态码
    switch (status) {
      case 400:
        errorInfo.type = ErrorType.VALIDATION;
        errorInfo.message = this.handleValidationError(data);
        break;
      case 401:
        errorInfo.type = ErrorType.AUTH;
        errorInfo.message = '登录已过期，请重新登录';
        // 可以在这里跳转到登录页
        break;
      case 403:
        errorInfo.type = ErrorType.AUTH;
        errorInfo.message = '权限不足，无法执行此操作';
        break;
      case 404:
        errorInfo.type = ErrorType.SERVER;
        errorInfo.message = '请求的资源不存在';
        break;
      case 500:
        errorInfo.type = ErrorType.SERVER;
        errorInfo.message = '服务器内部错误，请稍后重试';
        break;
      default:
        errorInfo.type = ErrorType.SERVER;
        errorInfo.message = data?.message || `请求失败 (${status})`;
    }

    errorInfo.details = data;
    ElMessage.error(errorInfo.message);
    return errorInfo;
  }

  /**
   * 处理验证错误
   * @param data 错误数据
   */
  private static handleValidationError(data: any): string {
    if (data?.errors) {
      const errorMessages: string[] = [];
      
      // 处理字段验证错误
      Object.keys(data.errors).forEach(field => {
        const fieldErrors = data.errors[field];
        if (Array.isArray(fieldErrors)) {
          fieldErrors.forEach((error: string) => {
            errorMessages.push(error);
          });
        }
      });

      if (errorMessages.length > 0) {
        return errorMessages.join('; ');
      }
    }

    return data?.title || '数据验证失败，请检查输入信息';
  }

  /**
   * 处理业务逻辑错误
   * @param response API响应
   * @param successMessage 成功消息
   */
  static handleBusinessError(response: any, successMessage?: string): boolean {
    if (response.data.code === 200) {
      if (successMessage) {
        ElMessage.success(successMessage);
      }
      return true;
    } else {
      ElMessage.error(response.data.msg || '操作失败');
      return false;
    }
  }

  /**
   * 显示成功消息
   * @param message 消息内容
   */
  static showSuccess(message: string): void {
    ElMessage.success(message);
  }

  /**
   * 显示错误消息
   * @param message 消息内容
   */
  static showError(message: string): void {
    ElMessage.error(message);
  }

  /**
   * 显示警告消息
   * @param message 消息内容
   */
  static showWarning(message: string): void {
    ElMessage.warning(message);
  }

  /**
   * 显示信息消息
   * @param message 消息内容
   */
  static showInfo(message: string): void {
    ElMessage.info(message);
  }
}

export default ErrorHandler; 